package cn.wgspring.wedding_helper.model

import androidx.compose.runtime.mutableStateListOf
import cn.wgspring.wedding_helper.util.CSVReader
import cn.wgspring.wedding_helper.settings.StorageManager

// 婚礼当天物品检查清单
class WeddingCheckList {
    // 使用可变状态列表，以便在添加、删除或修改时能够自动触发重组
    private val _items = mutableStateListOf<CheckListItem>()
    val items: List<CheckListItem> get() = _items
    
    // 存储使用方的顺序
    private val userGroupOrder = mutableListOf<String>()
    
    // 存储管理器实例
    private val storageManager = StorageManager.getInstance()
    
    init {
        loadItems()
    }
    
    // 加载物品，优先使用本地存储数据
    private fun loadItems() {
        // 首先清空现有数据
        _items.clear()
        userGroupOrder.clear()
        
        // 获取本地存储的使用方顺序
        val savedUserGroupOrder = storageManager.getUserGroupOrder()
        if (savedUserGroupOrder.isNotEmpty()) {
            userGroupOrder.addAll(savedUserGroupOrder)
        }
        
        // 获取本地存储的所有物品
        val savedItems = storageManager.getCheckItems()
        
        if (savedItems.isNotEmpty()) {
            // 如果本地有存储的物品，优先使用
            _items.addAll(savedItems.filter { !it.isDeleted })
            
            // 如果没有保存使用方顺序，从物品中提取
            if (userGroupOrder.isEmpty()) {
                val groups = savedItems.map { it.userGroup }.distinct()
                userGroupOrder.addAll(groups)
            }
        } else {
            // 本地没有存储数据，加载默认数据
            loadDefaultItems()
        }
    }
    
    // 从默认数据加载物品
    private fun loadDefaultItems() {
        // 加载默认结构和用户组顺序
        loadDefaultStructure()
        
        // 加载默认物品
        val csvLines = CSVReader.readCSVContent(RawData.SHOPPING_LIST_CHECK)
        // 跳过标题行
        if (csvLines.size > 1) {
            var currentUserGroup = ""
            var nextId = 1
            
            // 从第二行开始解析数据
            for (i in 1 until csvLines.size) {
                val line = csvLines[i]
                if (line.size >= 4) {
                    // 如果第二列为空，说明这是一个使用方（用户组）行
                    if (line[1].isBlank() && line[0].isNotBlank()) {
                        currentUserGroup = line[0]
                    } else if (line[1].isNotBlank()) {
                        // 创建检查清单项
                        val confirmed = line[0].trim().isNotEmpty()
                        val name = line[1].trim()
                        val purpose = line[2].trim()
                        val location = line[3].trim()
                        
                        val item = CheckListItem(
                            id = nextId++,
                            name = name,
                            userGroup = currentUserGroup,
                            purpose = purpose,
                            location = location,
                            confirmed = confirmed,
                            userDefined = false,
                            isDeleted = false
                        )
                        // 设置初始状态
                        item.isConfirmed = confirmed
                        _items.add(item)
                    }
                }
            }
            
            // 保存导入的默认物品到本地存储
            if (_items.isNotEmpty()) {
                storageManager.saveCheckItems(_items)
                storageManager.saveUserGroupOrder(userGroupOrder)
            }
        }
    }
    
    // 从默认数据中加载结构，确定顺序
    private fun loadDefaultStructure() {
        val csvLines = CSVReader.readCSVContent(RawData.SHOPPING_LIST_CHECK)
        // 跳过标题行
        if (csvLines.size > 1) {
            var currentUserGroup = ""
            
            // 从第二行开始解析数据
            for (i in 1 until csvLines.size) {
                val line = csvLines[i]
                if (line.size >= 4) {
                    // 如果第二列为空，说明这是一个使用方（用户组）行
                    if (line[1].isBlank() && line[0].isNotBlank()) {
                        currentUserGroup = line[0]
                        if (!userGroupOrder.contains(currentUserGroup)) {
                            userGroupOrder.add(currentUserGroup)
                        }
                    }
                }
            }
        }
    }
    
    // 获取按使用方分组的物品
    fun getItemsByUserGroup(): Map<String, List<CheckListItem>> {
        // 分组物品
        val groupedItems = items.groupBy { it.userGroup }
        
        // 创建一个有序的LinkedHashMap，保持使用方的顺序
        val orderedResult = linkedMapOf<String, List<CheckListItem>>()
        
        // 按照userGroupOrder的顺序添加物品组
        userGroupOrder.forEach { userGroup ->
            groupedItems[userGroup]?.let { items ->
                orderedResult[userGroup] = items
            }
        }
        
        // 添加任何可能没有在预定义顺序中的使用方（以防万一）
        groupedItems.keys.forEach { userGroup ->
            if (!orderedResult.containsKey(userGroup)) {
                orderedResult[userGroup] = groupedItems[userGroup]!!
            }
        }
        
        return orderedResult
    }
    
    // 删除物品
    fun removeItem(item: CheckListItem) {
        // 标记物品为已删除
        if (item.id > 0) {
            storageManager.markCheckItemAsDeleted(item.id)
        }
        
        // 从当前列表中删除
        _items.remove(item)
    }
    
    // 更新物品信息
    fun updateItem(oldItem: CheckListItem, newName: String, newPurpose: String, newLocation: String) {
        val index = _items.indexOf(oldItem)
        if (index != -1) {
            // 创建一个新的物品对象，保留原有的ID和使用方
            val newItem = CheckListItem(
                id = oldItem.id,
                name = newName,
                userGroup = oldItem.userGroup,
                purpose = newPurpose,
                location = newLocation,
                confirmed = oldItem.isConfirmed,
                userDefined = true,
                isDeleted = false
            )
            
            // 保存到本地存储
            val updatedItem = storageManager.updateCheckItem(newItem)
            
            // 替换原有物品
            _items[index] = updatedItem
        }
    }
    
    // 切换物品的确认状态
    fun toggleItemConfirmation(item: CheckListItem) {
        val newState = !item.isConfirmed
        item.isConfirmed = newState
        
        // 保存状态到本地存储
        if (item.id > 0) {
            storageManager.saveCheckItemState(item.id, newState)
        }
    }
    
    // 添加新物品
    fun addItem(item: CheckListItem) {
        // 如果使用方不在列表中，添加它
        if (!userGroupOrder.contains(item.userGroup)) {
            userGroupOrder.add(item.userGroup)
            
            // 保存更新后的使用方顺序
            storageManager.saveUserGroupOrder(userGroupOrder)
        }
        
        // 添加到本地存储并获取带ID的物品
        val savedItem = storageManager.addCheckItem(item)
        _items.add(savedItem)
    }
}